Instance 0

Class1060.run()#0{
                    URL url = classLoader.getResource(resourceName);
                    if (url != null) {
                      URLConnection connection = url.openConnection();
                      if (connection != null) {
                        connection.setUseCaches(false);
                        is = connection.getInputStream();
                      }
                    }
}


Instance 1

Class80.run()#0{
                                    URL url = classLoader.getResource(resourceName);
                                    if (url != null) {
                                        URLConnection connection = url.openConnection();
                                        if (connection != null) {
                                            // Disable caches to get fresh data for
                                            // reloading.
                                            connection.setUseCaches(false);
                                            is = connection.getInputStream();
                                        }
                                    }
}


Instance 2

Class940.getInputStream(ClassLoader loader,boolean reload,String resourceName)#0{
        if (!reload) { return loader.getResourceAsStream(resourceName); }
        URL url = loader.getResource(resourceName);
        if (url == null) { return null; }
        URLConnection connection = url.openConnection();
        if (connection == null) { return null; }
        connection.setUseCaches(false);
        return connection.getInputStream();
}


Instance 3

Class370.openConnection(URL url)#0{
        if (url.getProtocol().equals("https")) {
            for (String domain : sStaticCA.keySet()) {
                if (url.getHost().endsWith(domain)) {
                    return openCAConnection(sStaticCA.get(domain), url);
                }
            }
        }
        return url.openConnection();
}


Instance 4

Class1530.outputStreamFromURL(URL url){
        if ("file".equals(url.getProtocol())) {
            // as with inputStreamFromURL, avoid probs with Windows network mounts:
            String host = url.getHost();
            if (host == null || host.length() == 0) {
                return new FileOutputStream(url.getPath());
            }
        }
        return url.openConnection().getOutputStream();
}


Instance 5

Class970.reload(URL url){
        if (url != null)
        {
            URLConnection connection = url.openConnection();
            if (connection != null)
            {
                connection.setUseCaches(false);
                return connection.getInputStream();
            }
        }
}


Instance 6

Class1250.lastModified()#0{
    URL url = getURL();
    if (ResourceUtils.isFileURL(url) || ResourceUtils.isJarURL(url)) {
      // Proceed with file system resolution...
      return super.lastModified();
    }
    else {
      // Try a URL connection last-modified header...
      URLConnection con = url.openConnection();
      con.setUseCaches(false);
      if (con instanceof HttpURLConnection) {
        ((HttpURLConnection) con).setRequestMethod("HEAD");
      }
      return con.getLastModified();
    }
}


Instance 7

Class1250.contentLength()#0{
    URL url = getURL();
    if (ResourceUtils.isFileURL(url)) {
      // Proceed with file system resolution...
      return super.contentLength();
    }
    else {
      // Try a URL connection content-length header...
      URLConnection con = url.openConnection();
      con.setUseCaches(false);
      if (con instanceof HttpURLConnection) {
        ((HttpURLConnection) con).setRequestMethod("HEAD");
      }
      return con.getContentLength();
    }
}


Instance 8

Class1180.openConnection(final URL url)#0{
        final String path = url.getPath();
        if ( Strings.isNullOrEmpty( path ) )
        {
            throw new MalformedURLException( "Path can not be null or empty." );
        }
        final ResourceKey key = ResourceKey.from( path );
        final Bundle bundle = getBundle( key.getApplicationKey() );
        final URL resolvedUrl = bundle.getResource( key.getPath() );
        return resolvedUrl != null ? resolvedUrl.openConnection() : null;
}


Instance 9

Class210.lastModified()#2{
        URL url = getURL();
        if (GrailsResourceUtils.isFileURL(url) || GrailsResourceUtils.isJarURL(url)) {
            // Proceed with file system resolution...
            return getFile().lastModified();
        }
        URLConnection con = url.openConnection();
        useCachesIfNecessary(con);
        if (con instanceof HttpURLConnection) {
            ((HttpURLConnection) con).setRequestMethod("HEAD");
        }
        return con.getLastModified();
}


Instance 10

Class200.getInputStream(ClassLoader loader,String resourceName,boolean reload){
        URL url = loader.getResource(resourceName);
        if (url == null) {
            return null;
        }
        URLConnection connection = url.openConnection();
        connection.setUseCaches(!reload);
        return connection.getInputStream();
}


Instance 11

Class1430.getInputStream(String path){
            URL url = getResource(path);
            if (url == null) {
                return null;
            }
            URLConnection connection = url.openConnection();
            connection.setUseCaches(false);
            return connection.getInputStream();
}


Instance 12

Class740.get(String name)#0{
        if(resurl.getProtocol().equals("https"))
      c = ssl.connect(resurl);
        else
      c = resurl.openConnection();
        c.addRequestProperty("User-Agent", "Haven/1.0");
        return(c.getInputStream());
}


Instance 13

Class380.getResourceAsStream(String name){
        URL url = getResource(name);
        if (url != null) {
            try {
                URLConnection con = url.openConnection();
                con.setUseCaches(false);
                return con.getInputStream();
            } catch (IOException e) {
            }
        }
}


Instance 14

Class1400.getResourceAsStream(String resourceName,ClassLoader callingClass,boolean useCache){
    URL url = getResourceUrl(resourceName, callingClass);
    if (url != null) {
      URLConnection urlConnection = url.openConnection();
      urlConnection.setUseCaches(useCache);
      return urlConnection.getInputStream();
    }
}


Instance 15

Class640.getResource(String filename)#0{
            URL url = getClassLoader().getResource(filename);
            if (url == null) {
                return null;
            }
            URLConnection connection = url.openConnection();
            connection.setUseCaches(false);
            return connection.getInputStream();
}


Instance 16

Class920.get(String name){
      URL resurl = encodeurl(new URL(baseurl, name + ".res"));
      if(resurl.getProtocol().equals("https"))
    c = ssl.connect(resurl);
      else
    c = resurl.openConnection();
      c.addRequestProperty("User-Agent", "Haven/1.0");
      return(c.getInputStream());
}


Instance 17

Class250.loadDataFromURL(URL url,String contentType,Sail sail)#0{
        String lang = urlToModelLang(url, contentType);
        if (lang != null) {
            URLConnection conn = url.openConnection();
            
            //setRequestHeaders(conn, LongwellUtilities.getLabel() + "/" + LongwellUtilities.getVersion());
            
            conn.connect();
            InputStream stream = conn.getInputStream();
            try {
                loadDataFromStream(stream, url.toExternalForm(), lang, sail);
            } catch (Exception e) {
                throw new RuntimeException("Error loading data from URL: " + url + " " + e.getMessage());
            } finally {
                stream.close();
            }
        } else {
            throw new ModelReadFromFileException("Unknown data format in " + url.toExternalForm());
        }
}


Instance 18

Class20.getTestListReader(String location){
      URL url = getTestListURL( location );
      if(url != null) {
        URLConnection connection = url.openConnection();
        return new LineNumberReader( new InputStreamReader( connection.getInputStream() ) );
      }
}


Instance 19

Class680.getContent()#0{
      URL resourceURL = _servletContext.getResource(_resourcePath);
      if (resourceURL == null) {
        return null;
      }
      URLConnection urlConnection = resourceURL.openConnection();
      return StringUtil.read(urlConnection.getInputStream());
}


Instance 20

Class720.openStreamFromURL(URL url)#0{
    if (url == null) {
      throw new IllegalArgumentException("url must not be null!");
    }
    URLConnection connection = url.openConnection();
        setURLConnectionDefaults(connection);
        return connection.getInputStream();
}


Instance 21

Class330.getInputStream(String fileName){
    URL url = servletContext.getResource(resourcesDir.concat(fileName));
    if (url == null) {
      return null;
    }
    URLConnection urlConnection = url.openConnection();
    return urlConnection.getInputStream();
}


Instance 22

Class730.openStreamFromURL(URL url,int timeout)#0{
    if (url == null) {
      throw new IllegalArgumentException("url must not be null!");
    }
    URLConnection connection = url.openConnection();
    connection.setConnectTimeout(timeout);
    connection.setReadTimeout(timeout);
        return connection.getInputStream();
}


Instance 23

Class1090.getBitmapFromUrl(URL url,String cookies)#1{
    if (url == null)
      return null;
      connection = url.openConnection();
      connection.setUseCaches(true);
}


Instance 24

Class530.lastModified(){
    URL url = getURL();
    if (ResourceUtils.isFileURL(url) || ResourceUtils.isJarURL(url)) {
      // Proceed with file system resolution...
      return super.lastModified();
    }
    else {
      // Try a URL connection last-modified header...
      URLConnection con = url.openConnection();
      customizeConnection(con);
      return con.getLastModified();
    }
}


Instance 25

Class890.lastModified(){
        URL url = getURL();
        if (ResourceUtils.isFileURL(url) || ResourceUtils.isJarURL(url)) {
            // Proceed with file system resolution...
            return super.lastModified();
        } else {
            // Try a URL connection last-modified header...
            URLConnection con = url.openConnection();
            customizeConnection(con);
            return con.getLastModified();
        }
}


Instance 26

Class1530.recordTimestamp(String className,ClassLoader loader)#0{
        final URL file = loader.getResource(className.replace(".", "/") + ".class");
        className = className.replace("/", ".");
        if (file != null) {
            URLConnection connection = null;
            try {
                connection = file.openConnection();
                timestamps.put(className, connection.getLastModified());
                loaders.put(className, loader);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
}


Instance 27

Class890.contentLength()#0{
        URL url = getURL();
        if (ResourceUtils.isFileURL(url)) {
            // Proceed with file system resolution...
            return getFile().length();
        } else {
            // Try a URL connection content-length header...
            URLConnection con = url.openConnection();
            customizeConnection(con);
            return con.getContentLength();
        }
}


Instance 28

Class670.convertToLocalUrl(URL url){
        if (url.getProtocol().equals("bundle"))
        {
            try
            {
                url = ((URLHandlersBundleURLConnection)
                    url.openConnection()).getLocalURL();
            }
            catch (IOException ex)
            {
                // Ignore and add original url.
            }
        }
}


Instance 29

Class1000.connect(URL url)#0{
  if(!url.getProtocol().equals("https"))
      throw(new MalformedURLException("Can only be used to connect to HTTPS servers"));
  HttpsURLConnection conn = (HttpsURLConnection)url.openConnection();
}


Instance 30

Class530.contentLength()#0{
    URL url = getURL();
    if (ResourceUtils.isFileURL(url)) {
      // Proceed with file system resolution...
      return getFile().length();
    }
    else {
      // Try a URL connection content-length header...
      URLConnection con = url.openConnection();
      customizeConnection(con);
      return con.getContentLength();
    }
}


Instance 31

Class220.openConnection(URL u){
        final URL resourceUrl = classLoader.getResource(u.getPath());
        return resourceUrl != null ? resourceUrl.openConnection() : null;
}


Instance 32

Class1500.openConnection(URL url){
            return MEMORY_URL_PROTOCOL.equals(url.getProtocol()) ? new MemoryURLConnection(url, file) : url.openConnection();
}


Instance 33

Class1280.openConnection(URL u)#0{
                URL resource = Tools.getResource(u.getPath().substring(1, u.getPath().length()));
                if (resource != null) {
                  URLConnection conn = resource.openConnection();
                  WebServiceTools.setURLConnectionDefaults(conn);
                  return conn;
                }
}


Instance 34

Class720.openConnection(final URL url)#0{
      LOGGER.trace(String.format("Creating stream for resource <%s>, using class loader <%s>...",resource,classLoader));
    final URL resourceURL=classLoader.getResource(resource);
    if(resourceURL==null) {
      throw new IOException(String.format("Resource <%s> could not be found in the classpath.",resource));
    }
    return resourceURL.openConnection();
}


Instance 35

Class460.getResource(@NotNull ClassLoader loader,@NonNls @NotNull String basePath,@NonNls @NotNull String fileName)#0{
    List<String> bundles = calculateBundleNames(fixedPath, Locale.getDefault());
    for (String bundle : bundles) {
      URL url = loader.getResource(bundle + "/" + fileName);
      if (url == null) continue;

      try {
        url.openConnection();
      }
      catch (IOException e) {
        continue;
      }

      return url;
    }
    return loader.getResource(fixedPath + "/" + fileName);
}


Instance 36

Class1030.openConnection(URL u)#1{
                URL resource = Tools.getResource("icons" + u.getPath());
                if (resource != null) {
                  URLConnection conn = resource.openConnection();
                  WebServiceTools.setURLConnectionDefaults(conn);
                  return conn;
                }
}


Instance 37

Class570.openConnection(URL u)#0{
    IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
    String resourceId = nameAndLocation.substring(nameAndLocation.indexOf('/') + 1);
    ClassLoader cl = JdtUtils.getClassLoader(project, null);
    URL resource = cl.getResource(resourceId);
    if (resource != null) {
      return resource.openConnection();
    }
}


Instance 38

Class1270.getLastModified(String fileName){
        URL url = Externalization.class.getClassLoader().getResource(fileName);
        if (url != null) {
            URLConnection connection = url.openConnection();
            lastModified = connection.getLastModified();
        }
}


Instance 39

Class710.openConnection(final URL url){
        final ResourceKey key = ResourceKey.from( url.getPath() );
        final URL newUrl = this.registry.getUrl( key );
        if ( newUrl != null )
        {
            return newUrl.openConnection();
        }
}


Instance 40

Class1370.connect()#0{
            URL url = bundle.getEntry(bundlePath);
            if (url == null) {
                throw new IOException("Cannot find entry " + bundlePath
                    + " in bundle " + bundle + " for URL " + url);
            }
            delegatee = url.openConnection();
}


Instance 41

Class10.getURLConnection(String originalPath,boolean virtual){
        ServletContextAndPath csAndP = getServletContextAndPath(originalPath,
                virtual);
        ServletContext context = csAndP.getServletContext();
        String path = csAndP.getPath();
        URL url = context.getResource(path);
        if (url == null) {
            throw new IOException("Context did not contain resource: " + path);
        }
        URLConnection urlConnection = url.openConnection();
}


Instance 42

Class1380.connect()#0{
            URL contextURL = resourceProvider.getResource(url.getPath());
            if (contextURL == null) {
                throw new IOException("Resource " + url.getPath()
                    + " does not exist");
            }
            delegatee = contextURL.openConnection();
}


Instance 43

Class610.createAssetURLConnection(final String path){
        final URL url = AssetURLContext.createURL(path);
        final URLConnection c = url.openConnection();
        System.err.println("createAssetURL: "+path+" -> url: "+url+" -> conn: "+c+" / connURL "+(null!=c?c.getURL():null));
}


Instance 44

Class1450.createAssetURLConnection(final String path,final ClassLoader cl){
        final URL url = AssetURLContext.createURL(path, cl);
        final URLConnection c = url.openConnection();
        System.err.println("createAssetURL: "+path+" -> url: "+url+" -> conn: "+c+" / connURL "+(null!=c?c.getURL():null));
}


Instance 45

Class340.findCodeSourceConnectionFor(final String name)#0{
        final URL resource = findResource(name);
        if (resource != null) {
            try {
                return resource.openConnection();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
}


Instance 46

Class340.findCodeSourceConnectionFor(final String name)#1{
    final URL resource = findResource(name);
    if (resource != null) {
      try {
        return resource.openConnection();
      } catch (IOException e) {
        throw new RuntimeException(e);
      }
    }
}


Instance 47

Class1030.open(final URL url)#0{
        if(null==url) {
            return null;
        }
            final URLConnection c = url.openConnection();
            c.connect(); // redundant
}


Instance 48

Class1210.getConnection(JarFile jarFile){
        URL u = urlCache.get(jarFile);
        if (u != null)
            return u.openConnection();
}


Instance 49

Class180.openConnection(final URL url)#0{
    if (proxy != null) {
      connection = url.openConnection(proxy);
    } else {
      connection = url.openConnection();
    }
}


Instance 50

Class210.getImageIcon(URL url)#0{
   {  if (url==null) return null;
      {  url.openConnection().connect();
}


Instance 51

Class1360.getMimeType(final String name){
    URL resource = getResource(name);
    if (null != resource) {
      try {
        return resource.openConnection().getContentType();
      } catch (final IOException e) {
        return null;
      }
    }
}


Instance 52

Class1000.getConnection(final String key,boolean doNotThrowResourceNotFound)#1{
        final URL u = clazz.getResource(adjustedKey);
        if (u == null) {
            if (doNotThrowResourceNotFound) return null;
            else throw new ResourceNotFoundException(key);
        }
        return u.openConnection();
}


Instance 53

Class590.openConnection(URL url)#1{
    return (HttpURLConnection) (proxy == null ? url.openConnection() : url.openConnection(proxy));
}


Instance 54

Class520.lastModified(final String documentPath){
    final URL url = getBundle().getEntry(documentPath);
    if (url != null) {
      lastModified = url.openConnection().getLastModified();
    }
}


Instance 55

Class1060.getResource(String path){
            URL url = getClass().getResource(fullPath);
            if (url == null) {
                System.out.println("url is null: " + fullPath);
            }
            return new URLResource(url, url.openConnection(), path);
}